RT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;

#include<assert.h>

//void Friend();

class Date
{
	//friend void Friend();
	friend std::ostream& operator<<(std::ostream& out, const Date& d);
	friend std::istream& operator>>(std::istream& in, Date& d);
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day;
	}

	bool IsleapYear(int year)const
	{
		if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
			return true;
		else
			return false;
	}
	// 获取某年某月的天数
	int GetMonthDay(int year, int month)const
	{
		int arr[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		if (IsleapYear(year) && month == 2)
			return 29;
		else
			return arr[month];
	}
  // 全缺省的构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		if (year < 1
			|| month < 1 || month > 12
			|| day < 1 || day > GetMonthDay(year, month))
		{
			cout << "非法日期" << endl;
		}
		_year = year;
		_month = month;
		_day = day;
	}
	// 拷贝构造函数
	// d2(d1)
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	// 赋值运算符重载
	// d2 = d3 -> d2.operator=(&d2, d3)
	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}
	// 析构函数
	~Date()
	{
		//free(pdate);
	}
	// 日期+=天数
	Date& operator+=(int day)
	{
		_day += day;
		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			_month++;
			if (_month == 13)
			{
				_month=1;
				_year++;
			}
		}
		return *this;
	}
	// 日期+天数
	Date operator+(int day)const
	{
		Date tmp(*this);
		(tmp._day) += day;
		while (tmp._day > GetMonthDay(tmp._year, tmp._month))
		{
			tmp._day -= GetMonthDay(tmp._year, tmp._month);
			tmp._month += 1;
			if (tmp._month > 12)
			{
				tmp._month = 1;
				tmp._year += 1;
			}
		}
		return tmp;
	}
	// 日期-天数
	Date operator-(int day)const
	{
		Date tmp(*this);
		(tmp._day) -= day;
		while (tmp._day <= 0)
		{
			tmp._day += GetMonthDay(tmp._year, tmp._month);
			tmp._month -= 1;
			if (tmp._month == 0)
			{
				tmp._month += 12;
				tmp._year -= 1;
			}
		}
		return tmp;
	}
	// 日期-=天数
	Date& operator-=(int day)
	{
		_day -= day;
		while (_day <= 0)
		{
			_day += GetMonthDay(_year, _month);
			_month -= 1;
			if (_month == 0)
			{
				_month += 12;
				_year -= 1;
			}
		}
		return *this;
	}
	// 前置++
	Date& operator++()
	{
		return (*this)+= 1;
	}
	// 后置++
	Date operator++(int)
	{
		Date ret(*this);
		*this = *this + 1;
		return ret;
	}
	// 后置--
	Date operator--(int)
	{
		Date ret(*this);
		*this = *this - 1;
		return ret;
	}
	// 前置--
	Date& operator--()
	{
		return *this -= 1;
	}
	// >运算符重载
	bool operator>( Date& d)const
	{
		return d < *this;
	}
	// ==运算符重载
	bool operator==(const Date& d)const
	{
		return _year == d._year &&
			_month == d._month &&
			_day == d._day;
	}
	// >=运算符重载
	bool operator >= (const Date& d)const
	{
		return !(*this < d);
	}
	// <运算符重载
	bool operator < (const Date& d)const
	{
		
		if ((_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day))
			return true;
		else
			return false;
	}
	// <=运算符重载
	bool operator <= (const Date& d)const
	{
		return *this < d || *this == d;
	}
	// !=运算符重载
	bool operator != (const Date& d)const
	{
		return !(operator==(d));
	}
	// 日期-日期 返回天数 
	int operator-(const Date& d)const
	{
		int flag = 1;
		Date max = *this;
		Date min = d;
		if (*this < d)
		{
			max = d;
			min = *this;
			flag = -1;
		}
		int day = 0;
		while (min < max)

		{
			++(min);
			++day;
		}
		return day * flag;
	}
private:
	int _year;
	int _month;
	int _day;
};

//这两个是友元函数(因为需要在类外面访问类里面的成员变量)
//注意cin和cout的不同实现
//因为我们没有完全展开std namepace，所以写这个函数的时候需要自己指定std::


//回值为ostream是为了保证多次cout
std::ostream& operator<<(std::ostream& out, const Date& d)
{
	out << d._year << "-" << d._month << "-" << d._day << endl;
	return out;
}

//cin使用的是istream
std::istream& operator>>(std::istream& in, Date& d)
{
	int year, month, day;
	in >> year >> month >> day;
	//这里应该添加一个对日期的正确性判断
	if (year >= 0
		&& (month >= 1 && month <= 12)
		&& (day >= 1 && day <= d.GetMonthDay(year, month)))
	{//判断日期正确性
		d._year = year;
		d._month = month;
		d._day = day;
	}
	else
	{
		cout << "Date err!" << endl;
		exit(0);//日期错误直接终止程序
	}

	return in;
}

//void Friend()
//{
//	cout << "friend" << endl;
//	Date dd;
//	cout << dd._year << endl;
//	//cout << d._year << endl;
//}

///////////
//int main()
//{
//	Date d(2022, 1, 1);
//	Date e(1, 1, 1);
//
//	d += 180;
//	d.Print();
//
//	//Friend();
//	//Date d;
//	//d.Print();
//	return 0;
//}


//class A
//{
//public:
//	A(int a = 20)
//		:_a(a + 100)
//	{
//		//_a = a;
//		cout << _a << endl;
//	}
//private:
//	int _a;
//};
//int main()
//{
//	A a1(50);
//	return 0;
//}



//int main()
//{
//	//Date d1(2022, 3, 1);
//	//d1 += 31;
//	////d1.Print();
//
//	//Date d2(1, 4, 15);
//	//Date d3(2, 2, 2);
//	////d3 = d2 + 10;
//	////d3.Print();
//	//d2 -= 25;
//	//d2.Print();
//
//	//d3 - 10;
//	//d3.Print();
//	
//	Date d5(2001, 2, 28);
//	Date d6(2001, 1, 28);
//
//	//int day = d5 - d6;
//
//
//	//d5.Print();
//	//d6.Print();// 398   365+28+2
//	//++d5;
//	//d5.Print();
//	//int ret = (d1 != d3);
//	//cout << (d1 == d3) << endl;
//	cout << (d6 > d5) << endl;
//	//cout << (d5-d6) << endl;
//	return 0;
//}



//void Func(const Date& d)
//{
//	d.Print();
//}


//int main()
//{
//	Date d(2022, 1, 1);
//
//	d.Print();
//
//	Func(d);
//	return 0;
//}


class Solution {
public:
	Solution()
	{
		_sum += _tmp;
		_tmp++;
	}

	int Sum_Solution(int n) {
		Solution arr[5];

		return _sum;
	}
private:
	static int _tmp;
	static int _sum;
};

//这里tmp不是1开始应该是   先用类创建了一个对象再调用的
int Solution::_tmp = 0;
int Solution::_sum = 0;

//class Solution {
//public:
//	class Sum
//	{
//	public:
//		Sum()
//		{
//			_sum += _tmp;
//			_tmp++;
//		}
//	};
//	int Sum_Solution(int n) {
//		Sum arr[5];
//
//		return _sum;
//	}
//private:
//	static int _tmp;
//	static int _sum;
//};
//
////这里tmp不是1开始应该是   先用类创建了一个对象再调用的
//int Solution::_tmp = 1;
//int Solution::_sum = 0;


class TEST
{
public:
	TEST()
		:_x(100)
	{
		cout << "TEST" << endl;
	}
	~TEST()
	{
		cout << "~TEST" << endl;
	}
	TEST(const TEST& d)
	{
		cout << "TEST Copy" << endl;
		_x = d._x;
		//*this = d;
		//return *this;
	}
	//TEST& operator=(const TEST& d)
	//{
	//	cout << "operator" << endl;
	//	return *this;
	//}
private:
	int _x;
};


TEST f(TEST t1)
{
	TEST t2(t1);

	TEST t3 = t2;

	return t3;
}

int main()
{

	TEST T1;
	TEST T3 = T1;




	//Solution S;
	//int ret=S.Sum_Solution(1);

	//cout <<ret<<endl;

	//f(TEST());


	//TEST t1;
	//TEST t2(t1);

	//TEST t3 = t2;

	//Date t1;
	//Date t3 = t1;
	//拷贝构造加上构造然后优化成拷贝构造
	
	//A a1(1);
	//A a2 = 2; //A(2) -> A a2(A(2))  -->优化，直接构造


	return 0;
}
